package com.gzc.just.play.last.war.sceneserver.ai;

import com.gzc.just.play.last.war.sceneserver.gameobject.unit.NPC;
import com.gzc.just.play.last.war.sceneserver.gameobject.base.Position;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * NPC行为系统 - 管理NPC的AI行为
 * 
 * 映射自C++ SSAI_Hero 和 NPC行为系统
 * 提供完整的NPC行为控制
 * 
 * @author AI编程助手
 * @version 1.0
 */
public class NPCBehavior {
    
    private NPC npc;
    private BehaviorTree behaviorTree;
    private AIState currentState = AIState.IDLE;
    private Position homePosition;
    private long lastStateChangeTime = 0;
    private float patrolRadius = 100f;
    private float chaseRadius = 300f;
    private float maxChaseDistance = 500f;
    
    // 行为监听器
    private List<NPCBehaviorListener> listeners = new CopyOnWriteArrayList<>();
    
    /**
     * 构造函数
     * 
     * @param npc NPC单位
     */
    public NPCBehavior(NPC npc) {
        this.npc = npc;
        Position pos = npc.getPosition();
        if (pos != null) {
            this.homePosition = new Position(pos.getX(), pos.getY(), pos.getZ());
        }
    }
    
    /**
     * 设置行为树
     * 
     * @param behaviorTree 行为树
     */
    public void setBehaviorTree(BehaviorTree behaviorTree) {
        this.behaviorTree = behaviorTree;
        if (behaviorTree != null) {
            behaviorTree.initialize();
        }
    }
    
    /**
     * 更新NPC行为（心跳处理）
     * 
     * @param currentTime 当前时间毫秒
     */
    public void update(long currentTime) {
        if (npc.getCurrentHealth() <= 0) {
            changeState(AIState.DEAD, currentTime);
            return;
        }
        
        // 执行行为树
        if (behaviorTree != null) {
            BehaviorNode.Result result = behaviorTree.tick(currentTime);
            handleBehaviorResult(result, currentTime);
        }
    }
    
    /**
     * 处理行为树的结果
     * 
     * @param result 行为结果
     * @param currentTime 当前时间
     */
    private void handleBehaviorResult(BehaviorNode.Result result, long currentTime) {
        switch (result) {
            case SUCCESS:
                // 行为成功，可以更新状态
                break;
            case FAILURE:
                // 行为失败，恢复默认状态
                if (currentState != AIState.IDLE && currentState != AIState.PATROL) {
                    changeState(AIState.IDLE, currentTime);
                }
                break;
            case RUNNING:
                // 行为运行中，继续执行
                break;
        }
    }
    
    /**
     * 改变AI状态
     * 
     * @param newState 新状态
     * @param currentTime 当前时间
     */
    public void changeState(AIState newState, long currentTime) {
        if (currentState != newState) {
            AIState oldState = currentState;
            currentState = newState;
            lastStateChangeTime = currentTime;
            
            // 触发状态变化事件
            notifyStateChanged(oldState, newState, currentTime);
        }
    }
    
    /**
     * 设置巡逻范围
     * 
     * @param radius 巡逻半径
     */
    public void setPatrolRadius(float radius) {
        this.patrolRadius = Math.max(0, radius);
    }
    
    /**
     * 设置追击范围
     * 
     * @param radius 追击半径
     */
    public void setChaseRadius(float radius) {
        this.chaseRadius = Math.max(0, radius);
    }
    
    /**
     * 设置最大追击距离
     * 
     * @param distance 最大追击距离
     */
    public void setMaxChaseDistance(float distance) {
        this.maxChaseDistance = Math.max(0, distance);
    }
    
    /**
     * 获取当前AI状态
     * 
     * @return AI状态
     */
    public AIState getCurrentState() {
        return currentState;
    }
    
    /**
     * 获取家园位置
     * 
     * @return 家园位置
     */
    public Position getHomePosition() {
        return homePosition;
    }
    
    /**
     * 设置家园位置
     * 
     * @param position 新的家园位置
     */
    public void setHomePosition(Position position) {
        if (position != null) {
            this.homePosition = new Position(position.getX(), position.getY(), position.getZ());
        }
    }
    
    /**
     * 获取巡逻范围
     * 
     * @return 巡逻半径
     */
    public float getPatrolRadius() {
        return patrolRadius;
    }
    
    /**
     * 获取追击范围
     * 
     * @return 追击半径
     */
    public float getChaseRadius() {
        return chaseRadius;
    }
    
    /**
     * 获取最大追击距离
     * 
     * @return 最大追击距离
     */
    public float getMaxChaseDistance() {
        return maxChaseDistance;
    }
    
    /**
     * 获取行为树
     * 
     * @return 行为树
     */
    public BehaviorTree getBehaviorTree() {
        return behaviorTree;
    }
    
    /**
     * 添加行为监听器
     * 
     * @param listener 监听器
     */
    public void addListener(NPCBehaviorListener listener) {
        if (listener != null) {
            listeners.add(listener);
        }
    }
    
    /**
     * 移除行为监听器
     * 
     * @param listener 监听器
     */
    public void removeListener(NPCBehaviorListener listener) {
        listeners.remove(listener);
    }
    
    /**
     * 通知状态变化
     * 
     * @param oldState 旧状态
     * @param newState 新状态
     * @param currentTime 当前时间
     */
    private void notifyStateChanged(AIState oldState, AIState newState, long currentTime) {
        for (NPCBehaviorListener listener : listeners) {
            listener.onStateChanged(npc, oldState, newState, currentTime);
        }
    }
    
    /**
     * 销毁行为系统
     */
    public void destroy() {
        if (behaviorTree != null) {
            behaviorTree.destroy();
            behaviorTree = null;
        }
        listeners.clear();
    }
    
    /**
     * NPC行为监听器接口
     */
    public interface NPCBehaviorListener {
        /**
         * 状态变化事件
         * 
         * @param npc NPC单位
         * @param oldState 旧状态
         * @param newState 新状态
         * @param currentTime 当前时间
         */
        void onStateChanged(NPC npc, AIState oldState, AIState newState, long currentTime);
    }
}
